\documentclass[10.5pt, a4paper]{article}

\usepackage{xeCJK}
\newCJKfontfamily{\heiti}[AutoFakeBold={3.17}]{SimHei}

\usepackage{geometry}
\geometry{
    left = 0.6in,
    right = 0.6in,
    top = 0.8in,
    bottom = 1.0in
}
\usepackage{amssymb,amsbsy,amsmath,xcolor,mathrsfs,graphicx}
\usepackage{listings}
\usepackage{tasks}
\settasks{
    label = \Alph*. ,
    label-width = 16pt
}

\renewcommand{\title}[2]{
    \begin{center}
        \Large\heiti #1~年~#2~月 Python~三级考试
    \end{center}
}
\newcommand{\TimeAndName}[1]{
    \begin{center}
        考试时间:~#1~ 分钟 \qquad\qquad\qquad\qquad 姓名:\underline{\quad\quad\quad\quad}
    \end{center}
}

\begin{document}
    \lstset{
        language = python,
        keywordstyle = \color{orange}\bfseries,
        emph = {print,bool,chr,ord,sorted,float,type,oct,hex,abs,sum,len,int,open,list,map,divmod,range,round,dir},
        emphstyle = \color{purple}\bfseries,
        showspaces = false,
        basicstyle = \ttfamily,
        morekeywords = {True,False}
    }

    \title{2021}{9}
    
    \TimeAndName{60}
    
    \vspace{1cm}
    {\noindent\heiti 第一部分、单选题(共 25 题,每题 2 分,共50分.)}

    \begin{enumerate}
        % 1
        \item 使用\lstinline!map()!函数可以实现列表数据元素类型的转换，而无需通过循环。则将列表\lstinline!L=['1','3','5','7','9']!转换为列表\lstinline![1,3,5,7,9]!的函数写法为?(\qquad)
        \begin{tasks}(4)
            \task map(int, L)
            \task list(map(int, L))
            \task map(L, int)
            \task list(map(L, int))
        \end{tasks}

        % 2
        \item 以下关于\lstinline!len()!函数的说法中错误的是?(\qquad)
        \begin{tasks}(2)
            \task len()函数可以用于返回字符串中的字符数
            \task len()函数可以用于返回列表中的元素个数
            \task len(\lstinline!"I love China"!)的结果为10
            \task len(\lstinline!"I love China"!)的结果为12
        \end{tasks}

        % 3
        \item 关于Python异常处理的解释，描述正确的是?(\qquad)
        \begin{tasks}
            \task 一般情况下，在Python正常处理程序时也会发生一个异常
            \task 异常处理增加了程序代码长度，降低了可读性
            \task 在程序中加入异常处理会使程序出现错误
            \task 当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行
        \end{tasks}

        % 4
        \item Python文件常用的写入方式有w+和a+,它们的相同点是?(\qquad)
        \begin{tasks}(2)
            \task 覆盖写
            \task 追加写
            \task 若文件不存在就创建
            \task 每次写的时候会自动覆盖上一次的内容
        \end{tasks}

        % 5
        \item Python标准库math中用来计算平方根的函数方面?(\qquad)
        \begin{tasks}(4)
            \task sqrt()
            \task max()
            \task min()
            \task print()
        \end{tasks}

        % 6
        \item 某同学上完体育课回教室发现丢失了重要的物品，于是他找到班主任求助。班主任打开视频监控，然后把视频进度拖到这节课中间时间点，发现水杯已经丢了，于是判定是前半节课丢的。接着又把视频进度拖到前面一半的一半......重复以上过程，很快就锁定了物品丢失的真相。以上描述，体现出了哪一种算法思想?(\qquad)
        \begin{tasks}(4)
            \task 二分法
            \task 选择排序法
            \task 递归法
            \task 迭代法
        \end{tasks}

        % 7
        \item 去掉列表中的部分数据，例如去掉列表[1,2,3,4,5,6,7,8,9]中3的倍数，可以使用哪一函数来实现？?(\qquad)
        \begin{tasks}(4)
            \task map()
            \task filter()
            \task zip()
            \task enumerate()
        \end{tasks}

        % 8
        \item 如下代码输出的结果是?(\qquad)
        \begin{lstlisting}
            num=list(range(3,6))
            print(num)
        \end{lstlisting}
        \begin{tasks}(4)
            \task \lstinline![0,1,2,3]!
            \task \lstinline![0,1,2,3,4,5,6]!
            \task \lstinline![3,4,5]!
            \task \lstinline![3,4,5,6]!
        \end{tasks}

        % 9
        \item \lstinline!print(divmod(34,8))!运行结果是?(\qquad)
        \begin{tasks}(4)
            \task 4 2
            \task 4
            \task 2
            \task 2 4
        \end{tasks}

        % 10
        \item 八进制10对应的十进制值是?(\qquad)
        \begin{tasks}(4)
            \task 8
            \task 10
            \task 20
            \task 24
        \end{tasks}

        % 11
        \item a=3.1415926,\lstinline!round(a,2)!运行结果是?(\qquad)
        \begin{tasks}(4)
            \task 3
            \task 3.14
            \task 3.141
            \task 3.1415926
        \end{tasks}

        \newpage
        % 12
        \item Python内置函数中用来返回序列中的最小元素?(\qquad)
        \begin{tasks}(4)
            \task mini()
            \task read()
            \task max()
            \task min()
        \end{tasks}

        % 13
        \item 下面表达式的运行结果与\lstinline!print(divmod(37,9))!运行结果相同的是?(\qquad)
        \begin{tasks}(4)
            \task print(37\%9, 37//9)
            \task print((37\%9, 37//9))
            \task print(37//9, 37\%9)
            \task print((37//9, 37\%9))
        \end{tasks}

        % 14
        \item 已知输入变量\lstinline!x='hello world'!,调用函数\lstinline!x.replace("I','h')!的结果为?(\qquad)
        \begin{tasks}(4)
            \task \lstinline!'hello world'!
            \task \lstinline!'lello world'!
            \task \lstinline!'hello worhd'!
            \task \lstinline!'hehho worhd'!
        \end{tasks}
        
        % 15
        \item 下列十六进制数中，转换为二进制数后含有偶数个“1”的是?(\qquad)
        \begin{tasks}(4)
            \task 0xF8
            \task 0xE0
            \task 0xA9
            \task 0x15
        \end{tasks}

        % 16
        \item 以下表达式是十六进制整数的选项导?(\qquad)
        \begin{tasks}(4)
            \task 16
            \task 0b16
            \task 0x16
            \task \lstinline!'0x16'!
        \end{tasks}

        % 17
        \item 给已有文件“实验中学学生花名册.txt”增加两名学生而且不能覆盖原有的内容。下面代码正确的是？?(\qquad)
        \begin{tasks}(2)
            \task 
            \lstinline{filename="实验中学学生花名册.txt"}\\
            \lstinline{with open(filename,"w")as f:}\\
            \lstinline{\ \ \ \ f.write("黎明\\n")}\\
            \lstinline{\ \ \ \ f.write("方芳\\n")}

            \task 
            \lstinline{filename="实验中学学生花名册.txt"}\\
            \lstinline{with open(filename,"r")as f:}\\
            \lstinline{\ \ \ \ f.write("黎明\\n")}\\
            \lstinline{\ \ \ \ f.write("方芳\\n")}

            \task 
            \lstinline{filename="实验中学学生花名册.txt"}\\
            \lstinline{with open(filename,"r+")as f:}\\
            \lstinline{\ \ \ \ f.write("黎明\\n")}\\
            \lstinline{\ \ \ \ f.write("方芳\\n")}

            \task 
            \lstinline{filename="实验中学学生花名册.txt"}\\
            \lstinline{with open(filename,"a")as f:}\\
            \lstinline{\ \ \ \ f.write("黎明\\n")}\\
            \lstinline{\ \ \ \ f.write("方芳\\n")}
        \end{tasks}

        % 18
        \item 以下关于二进制整数的定义，正确的是?(\qquad)
        \begin{tasks}(4)
            \task 0B1014
            \task 0b1010
            \task 0b1019
            \task 0bC3F
        \end{tasks}

        % 19
        \item 设\lstinline!s="happy time"!,那么\lstinline!print(s[-2:])!的结果是?(\qquad)
        \begin{tasks}(4)
            \task me
            \task happy
            \task time
            \task ha
        \end{tasks}

        % 20
        \item 程序执行程序后，“中国诗人.txt”文件内容为?(\qquad)
        \begin{lstlisting}
            filename = "中国诗人.txt"
            with open(filename, "w") as file:
                file.write("唐 李白\n")
                file.write("唐 白居易\n")
        \end{lstlisting}
        \begin{tasks}(2)
            \task 唐~李白~唐~白居易
            \task 唐~李白\\
                  唐~白居易
            \task 唐~李白$\backslash$n~唐~白居易
            \task 唐~李白$\backslash$n~唐~白居易$\backslash$n
        \end{tasks}

        % 21
        \item \lstinline!ord()!函数可以将一个字符转化成ascii码值，而\lstinline!chr()!函数则是相反的过程。已知\lstinline!'a'!的ascii码值为97,'A'的\lstinline!ascii!码值为65,则Python完成小写转大写的核心什码为?(\qquad)
        \begin{lstlisting}
            a = input("请输入一个小写字母:")
            b = __________
            print("转化结果为:"+b)
        \end{lstlisting}
        \begin{tasks}(4)
            \task chr(ord(a)-31)
            \task ord(chr(a)-32)
            \task chr(ord(a)+32)
            \task chr(ord(a)-32)
        \end{tasks}

        % 22
        \item 关于文件的读写，下列解释表述错误的是?(\qquad)
        \begin{tasks}(4)
            \task 读取模式\lstinline!('r')!
            \task 写入模式\lstinline!('w')!
            \task 读写模式\lstinline!('w')!
            \task 附加模式\lstinline!('a')!
        \end{tasks}

        \newpage
        % 23
        \item 小明编写了一个插入排序的算法，为列表\lstinline!arr=[5,33,21,67,39,73,7,43]!中的数值进行排序，他在调试时，如下图所示有意修改了循环的次数，请问，现在代码运行后\lstinline!print(arr)!打印出的结果是?(\qquad)
        \begin{lstlisting}
        #插入排序范例调试
        arr = [5, 33, 21, 67, 39, 73, 7, 43]
        for i in range(1,4):  #请注意此处起、止两数各是多少！
            j = i
            k=arr[i]
            #每次循环选取一个数
            while j>0 and k<arr[j-1]: #从第二个数开始比较,若小于上一个数,则：
                arr[j] = arr[j-1] #将当前数改为上一个数
                j = j-1
            arr[j] = k
        #把上一个数改为当前数，完成两数的位置交换
        print(arr)
        \end{lstlisting}
        \begin{tasks}(2)
            \task \lstinline![5,33,21,67,39,73,7,43]!
            \task \lstinline![5,21,33,67,39,43,7,73]!
            \task \lstinline![5,21,33,39,67,7,73,43]!
            \task \lstinline![5,21,33,67,39,73,7,43]!
        \end{tasks}

        % 24
        \item 异常处理的作用是不想让程序终止，如果出错了需要特殊处理。下列实现异常处理的语句是?(\qquad)
        \begin{tasks}(4)
            \task if/else
            \task try/except
            \task Warning
            \task Error
        \end{tasks}

        % 25
        \item 小明想对列表\lstinline!arr=[5,33,21,67,39,73,7,43]!中的数值进行排序，于是编写了“冒泡排序”代码，代码如下，划线处应该填入哪段代码?(\qquad)
        \begin{tasks}(4)
            \task \lstinline!arr[j]>arr[i+1]:!
            \task \lstinline!arr[i]>arr[j+1]!
            \task \lstinline!arr[i]>arr[i+1]!
            \task \lstinline!arr[j]>arr[j+1]!
        \end{tasks}
    \end{enumerate}

    \vspace{1cm}
    {\noindent\heiti 第二部分、判断题(共 10 题,每题 2 分,共20分.)}
    \begin{enumerate}
        \setcounter{enumi}{25}
        %26
        \item \lstinline!readline()!执行结果为字符串，\lstinline!readlines()!执行结果为列表.(\qquad)
        
        %27
        \item 猜一个20以内的随机数二分法比顺序查找的效率更高.(\qquad)
        
        %28
        \item Python中避免使用反斜线\lstinline!'\'!指定文件路径时出错，如
        \lstinline!'\t'!;常常使用斜线\lstinline!'/'!或者双反斜线\lstinline!'\\'!.(\qquad)
        
        %29
        \item \lstinline!bool()!函数判断整数参数的布尔值时，只要是非0参数，结果就为\lstinline!True!.(\qquad)
        
        %30
        \item 二进制数转换为十六进制的方法是：从右到左将4位分成一段，左边不满4位的可以用0补满，分别转换为十六进制.(\qquad)
        
        %31
        \item Python中的\lstinline!dir()!函数是一个文件夹操作函数，其主要作用是创建一个文件夹.(\qquad)
        
        %32
        \item 二进制数与十六进制数的未位是“1”，各转换为十进制数后都是奇数.(\qquad)
        
        %33
        \item 在\lstinline!try-finally!异常处理结构中，无论是否发生异常，都
        会处理最后的代码.(\qquad)

        %34
        \item song.csv文件中第一列是歌曲名，使用以下Python程序可以把歌曲名单一一读取出来.(\qquad)
        \begin{lstlisting}
            import csv
            with open('song.csv', 'r') as f:
                reader = csv.reader(f)
                for i in reader:
                    print(i[0])
        \end{lstlisting}

        %35
        \item 执行代码\lstinline!x,y,z=sorted([1,3,2])!之后，变量y的值为1.(\qquad)
    \end{enumerate}

    \newpage
    {\noindent\heiti 第三部分、编程题(共 3 题,每题 10 分,共30分.)}
    \begin{enumerate}
        \setcounter{enumi}{35}
        
        \item 输入10个数据进行升序排序，并在这有序数据上插入一个数据，使之仍然有序。
        
        程序代码如下，请补全。
        \begin{lstlisting}
            lis = []
            for i in range(10):
                x = int(input('输入待排序数据%d:'%(i)))
                lis.append(x)
            for i in range(____1____):
                for j in range(i, len(lis)):
                    if ____2____:
                        lis[i], lis[j] = lis[j], lis[i]
            print(lis)
            n = int(input('请输入一个需要插入的数据:'))
            lis.append(n)
            for i in range(____3____):
                if ____4____:
                    for j in range(i, len(lis)):
                        lis[j], lis[-1] = ____5____
                    break
            print(lis)
        \end{lstlisting}
        \vfill

        \item 小文的运动时间数据存储在文件“sport.csv”中，数据内容如下图显示：
        
        下列代码实现了读取数据，求和并统计个数，输出平均时长，并保留2位小数，请你补全代码。
        \begin{figure}[htbp]
            \centering
            \begin{minipage}{.7\textwidth}
                \centering
                \begin{lstlisting}
                    import csv
                    with open("/data/____1____") as f:
                        rows = list(csv.reader(f))
                        s = 0
                        c = 0
                        for row in rows[1:]:
                            s += int(____2____)
                            c = c+1
                    print(round(____3____, 2))
                \end{lstlisting}
            \end{minipage}
            \begin{minipage}{.2\textwidth}
                \centering
                \includegraphics[width=.3\textwidth]{37.png}
            \end{minipage}
        \end{figure}
        

        \newpage
        \item 给定一个整数num,从1到num按照下面的规则返回每个数：
        
        如果这个数被3整除，返回'Apple'。

        如果这个数被5整除，返回'Pie'。

        如果这个数能同时被3和5整除，返回'ApplePie'。

        如果这个数既不能被3也不能被5整除，返回这个数字的字符串格式。

        \begin{lstlisting}
            n = int(input("请输入一个数字:"))
            results = []
            for i in range(1, ____1____):
                if ____2____:
                    results.append("ApplePie")
                elif i%3==0:
                    results.append("Apple")
                elif i%5==0:
                    results.append("Pie")
                else:
                    results.append(____3____)
            print(results)
        \end{lstlisting}
    \end{enumerate}

    \newpage
    \begin{center}
        \Huge \heiti 参考答案
    \end{center}

        \begin{tasks}[label=\arabic*.](5)
            \task B
            \task C
            \task D
            \task C
            \task A

            \task A
            \task B
            \task C
            \task A
            \task A

            \task B
            \task D
            \task D
            \task D
            \task C

            \task C
            \task D
            \task B
            \task A
            \task B

            \task D
            \task C
            \task D
            \task B
            \task D

            \task $\checkmark$
            \task $\checkmark$
            \task $\checkmark$
            \task $\checkmark$
            \task $\checkmark$

            \task $\times$
            \task $\checkmark$
            \task $\checkmark$
            \task $\checkmark$
            \task $\times$
        \end{tasks}

        \begin{enumerate}
            \setcounter{enumi}{35}
            \item \begin{lstlisting}
                10 #1
                lis[i]>lis[j] #2
                11 #3
                lis[-1]>lis[i] #4
                lis[-1], lis[j] #5
            \end{lstlisting}

            \item \begin{lstlisting}
                sport.csv, 'r' #1
                row #2
                s/c #3
            \end{lstlisting}

            \item \begin{lstlisting}
                n #1
                i%15==0 #2
                str(i) #3
            \end{lstlisting}
        \end{enumerate}
\end{document}